import fs from 'fs';
import path from 'path';
import { v4 as uuidv4 } from 'uuid';
import Jimp from 'jimp';

// 上传目录
const uploadsDir = path.join(process.cwd(), 'uploads');
const tempDir = path.join(process.cwd(), 'temp');

// 确保目录存在
if (!fs.existsSync(uploadsDir)) {
  fs.mkdirSync(uploadsDir, { recursive: true });
}
if (!fs.existsSync(tempDir)) {
  fs.mkdirSync(tempDir, { recursive: true });
}

/**
 * 查找图片中的文字区域并替换
 * @param {string} imagePath - 图片路径
 * @param {Object} textReplaceData - 替换参数
 * @returns {Promise<string>} - 处理后的图片路径
 */
async function replaceTextInImage(imagePath, textReplaceData) {
  const { originalText, newText, fontFamily = 'Arial', fontSize = 24, fontColor = '#000000' } = textReplaceData;
  
  try {
    // 使用Jimp处理图片
    const jimpImage = await Jimp.read(imagePath);
    const imageWidth = jimpImage.getWidth();
    const imageHeight = jimpImage.getHeight();
    
    // 模拟文字位置
    const wordPositions = findWordPositions(imageWidth, imageHeight, originalText);
    
    // 在原图上绘制白色矩形覆盖原文字区域
    wordPositions.forEach(pos => {
      // 创建一个白色矩形覆盖原文本区域
      jimpImage.scan(
        Math.floor(pos.x), 
        Math.floor(pos.y - pos.height), 
        Math.floor(pos.width), 
        Math.floor(pos.height),
        function(x, y, idx) {
          // 将该区域涂成白色
          this.bitmap.data[idx + 0] = 255; // R
          this.bitmap.data[idx + 1] = 255; // G
          this.bitmap.data[idx + 2] = 255; // B
          // Alpha 不变
        }
      );
    });
    
    // 获取颜色值
    const colorObj = Jimp.cssColorToHex(fontColor);
    const hexColor = parseInt(colorObj.substr(1), 16);
    
    try {
      // 尝试加载字体
      // 注意：这个操作在实际项目中可能需要预先加载并缓存字体
      // 默认情况下使用内置的字体
      const font = await Jimp.loadFont(Jimp.FONT_SANS_32_BLACK);
      
      // 在每个位置添加新文字
      for (const pos of wordPositions) {
        jimpImage.print(
          font,
          Math.floor(pos.x), 
          Math.floor(pos.y - pos.height),
          {
            text: newText,
            alignmentX: Jimp.HORIZONTAL_ALIGN_LEFT,
            alignmentY: Jimp.VERTICAL_ALIGN_TOP
          },
          Math.floor(pos.width), 
          Math.floor(pos.height)
        );
      }
    } catch (fontError) {
      console.warn('加载字体失败，使用默认绘制文字:', fontError);
      // 如果无法加载字体，可以绘制一个提示框
      for (const pos of wordPositions) {
        // 绘制一个边框来指示文字区域
        jimpImage.scan(
          Math.floor(pos.x),
          Math.floor(pos.y - pos.height),
          Math.floor(pos.width),
          Math.floor(pos.height),
          function(x, y, idx) {
            // 只有边缘绘制为黑色
            if (
              x === Math.floor(pos.x) || 
              x === Math.floor(pos.x + pos.width - 1) ||
              y === Math.floor(pos.y - pos.height) || 
              y === Math.floor(pos.y - 1)
            ) {
              this.bitmap.data[idx + 0] = 0; // R
              this.bitmap.data[idx + 1] = 0; // G
              this.bitmap.data[idx + 2] = 0; // B
            }
          }
        );
      }
    }
    
    // 保存结果
    const outputPath = path.join(tempDir, `${uuidv4()}.png`);
    await jimpImage.writeAsync(outputPath);
    
    return outputPath;
  } catch (error) {
    console.error('处理图片失败:', error);
    throw error;
  }
}

/**
 * 简单模拟查找文字位置
 * 实际项目中应使用真实OCR API
 */
function findWordPositions(imageWidth, imageHeight, text) {
  // 这是一个模拟函数，实际应用中需要集成OCR
  // 返回模拟的文字位置
  if (!text || text.length === 0) {
    return [];
  }
  
  // 简单估算：假设文字在图片中心位置
  const positions = [
    {
      x: Math.floor(imageWidth * 0.25),
      y: Math.floor(imageHeight * 0.5),
      width: Math.floor(text.length * 20), // 粗略估算文字宽度
      height: 40 // 粗略估算文字高度
    }
  ];
  
  return positions;
}

export default async function handler(req, res) {
  // 仅支持POST请求
  if (req.method !== 'POST') {
    return res.status(405).json({ message: '方法不允许' });
  }
  
  try {
    const fileId = req.query.fileId;
    const textReplaceData = req.body;
    
    // 验证参数
    if (!fileId) {
      return res.status(400).json({ message: '缺少文件ID' });
    }
    
    if (!textReplaceData.originalText || !textReplaceData.newText) {
      return res.status(400).json({ message: '缺少原始文字或替换文字' });
    }
    
    // 找到原始图片
    const uploadedFilePath = path.join(uploadsDir, fileId);
    if (!fs.existsSync(uploadedFilePath)) {
      return res.status(404).json({ message: '文件不存在' });
    }
    
    // 替换文字
    const processedImagePath = await replaceTextInImage(uploadedFilePath, textReplaceData);
    
    // 生成新的文件ID
    const newFileId = path.basename(processedImagePath);
    
    // 返回结果
    res.status(200).json({
      message: '文字替换成功',
      data: {
        fileId: newFileId,
        downloadUrl: `/api/image/download/${newFileId}`
      }
    });
    
  } catch (error) {
    console.error('图像文字替换失败:', error);
    res.status(500).json({ message: '图像文字替换失败: ' + error.message });
  }
}

export const config = {
  api: {
    bodyParser: {
      sizeLimit: '10mb',
    },
  },
}; 